package com.henu.ocr.service.serviceImpl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.henu.ocr.entity.Template;
import com.henu.ocr.entity.TemplateItem;
import com.henu.ocr.mapper.TemplateItemMapper;
import com.henu.ocr.mapper.TemplateMapper;
import com.henu.ocr.service.TemplateService;
import com.henu.ocr.util.JWTUtil;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import javax.annotation.Resource;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
@Service
public class TemplateServiceImpl implements TemplateService {

    @Resource
    private TemplateMapper templateMapper;
    @Resource
    private TemplateItemMapper templateItemMapper;

    @Override
    @Transactional
    public void createTemplate(Template template, List<TemplateItem> items, String token) {
        validateTemplate(template);

        templateMapper.insert(template);
        items.forEach(item -> {
            item.setTemplateId(template.getTemplateId());
            validateTemplateItem(item);
        });
        items.forEach(templateItemMapper::insert);
    }

    @Override
    @Transactional
    public void deleteTemplate(Integer templateId, String token) {
        templateMapper.deleteById(templateId);
        templateItemMapper.delete(new QueryWrapper<TemplateItem>()
                .eq("template_id", templateId));
    }

    @Override
    @Transactional
    public void updateTemplate(Template template, String token) {
        validateTemplate(template);
        templateMapper.updateById(template);
    }

    @Override
    public List<Template> getAllTemplates(String token) {
        return templateMapper.selectList(new QueryWrapper<>());
    }

    @Override
    @Transactional
    public void addItemsToTemplate(Integer templateId, List<TemplateItem> items, String token) {
        validateToken(token);
        checkTemplateExists(templateId);

        items.forEach(item -> {
            item.setTemplateId(templateId);
            validateTemplateItem(item);
            templateItemMapper.insert(item);
        });
    }

    @Override
    public Template getTemplateWithItems(Integer templateId, String token) {
        validateToken(token);
        Template template = templateMapper.selectById(templateId);
        if (template == null) {
            throw new IllegalArgumentException("模板不存在");
        }
        List<TemplateItem> items = templateItemMapper.selectList(
                new QueryWrapper<TemplateItem>().eq("template_id", templateId)
        );
        template.setItems(items);
        return template;
    }
    @Override
    @Transactional
    public void deleteTemplateItem(Integer templateId, Integer itemId, String token) {
        validateToken(token);
        checkTemplateExists(templateId);

        TemplateItem item = templateItemMapper.selectById(itemId);
        if (item == null || !item.getTemplateId().equals(templateId)) {
            throw new IllegalArgumentException("模板项不存在或不属于该模板");
        }
        templateItemMapper.deleteById(itemId);
    }

    private Integer validateToken(String token) {
        Map<String, String> userInfo = JWTUtil.getUserInfoByToken(token);
        if (userInfo == null || !userInfo.containsKey("userId")) {
            throw new IllegalArgumentException("无效令牌");
        }
        try {
            return Integer.parseInt(userInfo.get("userId"));
        } catch (NumberFormatException e) {
            throw new IllegalArgumentException("非法用户ID");
        }
    }

    private void validateTemplate(Template template) {
        if (template.getTemplateName() == null || template.getTemplateName().trim().isEmpty()) {
            throw new IllegalArgumentException("模板名称不能为空");
        }
        if (template.getImageExample() == null || template.getImageExample().trim().isEmpty()) {
            throw new IllegalArgumentException("示例图片不能为空");
        }
    }

    private void validateTemplateItem(TemplateItem item) {
        if (item.getX1() == null || item.getX2() == null ||
                item.getY1() == null || item.getY2() == null) {
            throw new IllegalArgumentException("坐标参数不能为空");
        }
        if (item.getItemName() == null || item.getItemName().trim().isEmpty()) {
            throw new IllegalArgumentException("项名称不能为空");
        }
    }

    private void checkTemplateExists(Integer templateId) {
        if (templateMapper.selectById(templateId) == null) {
            throw new IllegalArgumentException("模板不存在");
        }
    }
}